package com.smartmedi.ai.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.smartmedi.ai.domain.entity.JhInMrFile;
import com.smartmedi.ai.domain.vo.FtpFileVO;
import com.smartmedi.ai.mapper.JhInMrFileMapper;
import com.smartmedi.ai.service.JhInMrFileService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Base64;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @author XWQ
 * @description 针对表【JH_IN_MR_FILE(住院电子病历文件表（与JH_IN_MR通过RECORD_ID关联）)】的数据库操作Service实现
 * @createDate 2025-07-17 16:29:20
 */
@Service
@Slf4j
public class JhInMrFileServiceImpl extends ServiceImpl<JhInMrFileMapper, JhInMrFile>
        implements JhInMrFileService {

    @Value("${ftp.host:140.140.1.30}")
    private String ftpHost;

    @Value("${ftp.port:2121}")
    private int ftpPort;

    @Value("${ftp.username:jiahe}")
    private String ftpUsername;

    @Value("${ftp.password:jiahe}")
    private String ftpPassword;

    /**
     * 从FTP获取文件并保存到数据库
     *
     * @param ftpFilePath FTP文件路径（如：/path/to/file.pdf）
     * @param recordId    关联病历的ROWKEY
     * @param fileDesc    文件描述
     * @return 保存后的文件ID
     */
    @Override
    public Long importFromFtp(String ftpFilePath, String recordId, String fileDesc) {
        FTPClient ftpClient = null;
        try {
            // 连接FTP服务器
            ftpClient = new FTPClient();
            ftpClient.connect(ftpHost, ftpPort);
            boolean login = ftpClient.login(ftpUsername, ftpPassword);

            if (!login) {
                log.error("FTP登录失败，请检查用户名和密码");
                throw new RuntimeException("FTP登录失败，请检查用户名和密码");
            }

            // 设置被动模式
            ftpClient.enterLocalPassiveMode();
            // 设置二进制传输模式
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

            // 提取文件名
            String fileName = ftpFilePath.substring(ftpFilePath.lastIndexOf('/') + 1);

            // 下载文件内容
            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
            String remotePath = ftpFilePath.substring(0, ftpFilePath.lastIndexOf('/'));
            String remoteFile = ftpFilePath.substring(ftpFilePath.lastIndexOf('/') + 1);

            if (!remotePath.isEmpty()) {
                ftpClient.changeWorkingDirectory(remotePath);
            }

            boolean downloaded = ftpClient.retrieveFile(remoteFile, outputStream);

            if (!downloaded) {
                log.error("从FTP下载文件失败: {}", ftpFilePath);
                throw new RuntimeException("从FTP下载文件失败: " + ftpFilePath);
            }

            // 创建文件记录
            JhInMrFile fileRecord = new JhInMrFile();
            fileRecord.setFileName(fileName);
            fileRecord.setFileType(getContentType(fileName));
            fileRecord.setFileContent(Base64.getEncoder().encodeToString(outputStream.toByteArray()));
            fileRecord.setFileSize((long) outputStream.size());
            fileRecord.setRecordId(recordId);
            fileRecord.setFileDesc(fileDesc);
            fileRecord.setUploadUser("系统导入");
            fileRecord.setUploadTime(new Date());
            fileRecord.setCreateTime(new Date());
            fileRecord.setUpdateTime(new Date());

            // 保存到数据库
            save(fileRecord);

            return fileRecord.getId();

        } catch (IOException e) {
            log.error("从FTP导入文件失败", e);
            throw new RuntimeException("从FTP导入文件失败: " + e.getMessage());
        } finally {
            if (ftpClient != null && ftpClient.isConnected()) {
                try {
                    ftpClient.logout();
                    ftpClient.disconnect();
                } catch (IOException e) {
                    log.error("关闭FTP连接失败", e);
                }
            }
        }
    }
    
    /**
     * 根据条件分页查询文件列表
     *
     * @param page     分页参数
     * @param fileName 文件名关键字
     * @param fileType 文件类型
     * @param recordId 关联病历ID
     * @param sortField 排序字段
     * @param sortOrder 排序顺序
     * @return 分页结果
     */
    public Page<JhInMrFile> getFileList(Page<JhInMrFile> page, String fileName, String fileType, String recordId, String sortField, String sortOrder) {
        LambdaQueryWrapper<JhInMrFile> queryWrapper = new LambdaQueryWrapper<>();
        
        // 添加查询条件
        if (StringUtils.isNotBlank(fileName)) {
            queryWrapper.like(JhInMrFile::getFileName, fileName);
        }
        
        if (StringUtils.isNotBlank(fileType)) {
            if ("pdf".equalsIgnoreCase(fileType)) {
                queryWrapper.like(JhInMrFile::getFileType, "pdf");
            } else if ("image".equalsIgnoreCase(fileType)) {
                queryWrapper.likeRight(JhInMrFile::getFileType, "image/");
            } else if ("doc".equalsIgnoreCase(fileType)) {
                queryWrapper.and(wrapper -> wrapper
                        .like(JhInMrFile::getFileType, "word")
                        .or()
                        .like(JhInMrFile::getFileType, "document")
                        .or()
                        .like(JhInMrFile::getFileType, "spreadsheet")
                        .or()
                        .like(JhInMrFile::getFileType, "excel"));
            }
        }
        
        if (StringUtils.isNotBlank(recordId)) {
            queryWrapper.eq(JhInMrFile::getRecordId, recordId);
        }
        
        // 添加排序条件
        if (StringUtils.isNotBlank(sortField)) {
            if ("uploadTime".equals(sortField)) {
                queryWrapper.orderBy(true, "asc".equalsIgnoreCase(sortOrder), JhInMrFile::getUploadTime);
            } else if ("fileName".equals(sortField)) {
                queryWrapper.orderBy(true, "asc".equalsIgnoreCase(sortOrder), JhInMrFile::getFileName);
            } else if ("fileSize".equals(sortField)) {
                queryWrapper.orderBy(true, "asc".equalsIgnoreCase(sortOrder), JhInMrFile::getFileSize);
            } else {
                // 默认按上传时间降序
                queryWrapper.orderByDesc(JhInMrFile::getUploadTime);
            }
        } else {
            // 默认按上传时间降序
            queryWrapper.orderByDesc(JhInMrFile::getUploadTime);
        }
        
        return page(page, queryWrapper);
    }
    
    /**
     * 上传文件并保存到数据库
     *
     * @param file     文件
     * @param recordId 关联病历ID
     * @param fileDesc 文件描述
     * @return 保存后的文件ID
     */
    public Long uploadFile(MultipartFile file, String recordId, String fileDesc) throws IOException {
        if (file == null || file.isEmpty()) {
            throw new RuntimeException("上传文件不能为空");
        }
        
        // 创建文件记录
        JhInMrFile fileRecord = new JhInMrFile();
        fileRecord.setFileName(file.getOriginalFilename());
        fileRecord.setFileType(file.getContentType());
        
        // 读取文件内容并Base64编码
        byte[] fileBytes = file.getBytes();
        fileRecord.setFileContent(Base64.getEncoder().encodeToString(fileBytes));
        fileRecord.setFileSize(file.getSize());
        fileRecord.setRecordId(recordId);
        fileRecord.setFileDesc(fileDesc);
        fileRecord.setUploadUser("用户上传");
        fileRecord.setUploadTime(new Date());
        fileRecord.setCreateTime(new Date());
        fileRecord.setUpdateTime(new Date());
        
        // 保存到数据库
        save(fileRecord);
        
        return fileRecord.getId();
    }
    
    /**
     * 获取文件内容
     *
     * @param fileId 文件ID
     * @return 文件内容的字节数组
     */
    public byte[] getFileContent(Long fileId) {
        JhInMrFile file = getById(fileId);
        if (file == null || StringUtils.isBlank(file.getFileContent())) {
            throw new RuntimeException("文件不存在或内容为空");
        }
        
        return Base64.getDecoder().decode(file.getFileContent());
    }
    
    /**
     * 根据文件类型和路径从FTP服务器采集文件
     * 
     * @param ftpRootPath FTP根路径
     * @param mrSn 病历号（用于生成FTP路径）
     * @param recordId 关联病历ID
     * @return FTP文件信息
     */
    public List<FtpFileVO> collectFilesFromFtpByMrSn(String ftpRootPath, String mrSn, String recordId) {
        // 实现从FTP采集文件的逻辑，将在另一个专门的方法中实现
        // 这里应该调用generateFtpPath方法生成路径，然后从FTP获取文件
        // 出于简洁考虑，具体实现略过
        throw new UnsupportedOperationException("此功能将在FileCollectionService中实现");
    }
    
    /**
     * 生成文件预览URL
     *
     * @param fileId 文件ID
     * @return 预览URL
     */
    public String generatePreviewUrl(Long fileId) {
        // 实际项目中，可能需要生成一个临时URL或使用文件服务器进行预览
        // 这里简化处理，直接返回下载链接
        return "/ai/file/download/" + fileId;
    }
    
    /**
     * 获取文件的Content-Type
     * @param fileName 文件名
     * @return Content-Type
     */
    private String getContentType(String fileName) {
        if (fileName == null) {
            return "application/octet-stream";
        }
        
        fileName = fileName.toLowerCase();
        
        if (fileName.endsWith(".txt")) {
            return "text/plain";
        } else if (fileName.endsWith(".doc")) {
            return "application/msword";
        } else if (fileName.endsWith(".docx")) {
            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
        } else if (fileName.endsWith(".pdf")) {
            return "application/pdf";
        } else if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) {
            return "image/jpeg";
        } else if (fileName.endsWith(".png")) {
            return "image/png";
        } else if (fileName.endsWith(".gif")) {
            return "image/gif";
        } else if (fileName.endsWith(".xls")) {
            return "application/vnd.ms-excel";
        } else if (fileName.endsWith(".xlsx")) {
            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        } else {
            return "application/octet-stream";
        }
    }
}




